#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define Max_Size 114514
struct node
{
    int elem;
    struct node *prev;
    struct node *next;
};
typedef struct node INTLIST;

INTLIST *Add_Elem(int input,INTLIST *start)
{
    INTLIST *temp;
    temp=(INTLIST*)malloc(sizeof(INTLIST));
    temp->elem=input;
    if(start==NULL)
    {
        temp->next=temp;
        temp->prev=temp;
        return temp;
    }
    else
    {
        temp->next=start;
        temp->prev=start->prev;
        start->prev->next=temp;
        start->prev=temp;
        return start;
    }//新元素插在理论上的队尾，反正这种链表插队尾跟插队头没什么区别（确信）
}//在链表尾部插入元素，时间复杂度为O(1)。
/*算法逻辑：直接设定两个指针
一个指针查前半一个指针查后半，查到两个指针对应的元素值不一样则直接返回false
如查找正常结束后，还没发现前后不一样的元素（即确定是对称链表）就返回true
这题的考察点果然还是构建双向循环链表的过程吧（确信）
算法中每个链表元素都会在循环体中被检查一遍，时间复杂度为O(n)。*/
int symmetry_check(INTLIST *start)
{
    INTLIST *left,*right;
    left=start;
    right=start->prev;
    while(1)
    {
        if(left->elem!=right->elem) return 0;//False
        left=left->next;
        right=right->prev;
        if(left==right||left->prev==right) break;
    }//后置终点判定，防止由于双向循环链表的特殊性一开始就结束循环
    return 1;//True
}

int main()
{
    char line[Max_Size];
    while(gets(line)!=NULL)
    {
        int temp=0,j=0;
        INTLIST *start1=NULL;
        for(j;j!=strlen(line);++j)
        {
            if(line[j]>='0'&&line[j]<='9')
            {
                temp=temp*10+(line[j]-'0');
            }
            else
            {
                start1=Add_Elem(temp,start1);
                temp=0;
            }
        }
        if(line[j-1]>='0'&&line[j-1]<='9')
        {
            
            start1=Add_Elem(temp,start1);
            temp=0;
        }
        printf("%d\n",symmetry_check(start1));
    }
    system("pause");
    return 0;
}